import AddScore from "./AddScore";

//设置之间间隔和时间变量
let ranTime = 2000,timer = 0;
//设置用来装柱子的集合
let zhuArr = [];
export default class extends Laya.Script {

    //挂在场景中的柱子生成脚本

    //设置自身为Sprit精灵类型，方便获取Script的各种属性
    owner=this.owner as Laya.Sprite;
    //一个新的柱子为预制体类型，装生成的柱子，方便获取属性
    zhu = new Laya.Prefab;
    //设置zhuManage为Sprit精灵类型，方便获取Script的各种属性。
    //柱子都会在该精灵容器下生成
    zhuManage = new Laya.Sprite;
    //设置游戏结束开关
    isOver = true;
    constructor() { super(); 
        //可视化，可以在场景脚本中直接拉入预制体，直接获取预制体
        /** @prop {name:zhu, tips:"柱子", type:Prefab, default:null}*/
        this.zhu=null;  
        //在场景脚本中直接拉入zhuManage，直接获取柱子管理容器
        /** @prop {name:zhuManage, tips:"柱子管理", type:Node, default:null}*/
        this.zhuManage=null; 
    }
    onAwake(){
    //监听Over事件，调用Over方法，就是游戏结束方法
    Laya.stage.on("Over",this,this.Over);
    //监听Start事件，调用GameStart方法，就是游戏开始方法
    Laya.stage.on("Start",this,this.GameStart);
    //监听Again事件，调用Again方法，就是再来一次方法
    Laya.stage.on("Again",this,this.Again);
    }
    
    onUpdate(){
        //如果游戏结束，就返回
        if(this.isOver) return;
        //时间变量增加，增加量为两帧之间的时间间隔，onUpdate()为每帧执行
        timer += Laya.timer.delta;
        //时间变量大于等于时间间隔，则执行
        if(timer >= ranTime){
            //重置时间变量，重新计时
            timer = 0;
            //时间变量设置成随机时间，达到柱子随机时间生成，可以自己调
            //this.getRandom（）封装好的随机数方法，在最下面
            ranTime = this.getRandom(2000,3000);
            //调用生成柱子的方法
            this.spawn();
        }
    }
    //生成柱子的方法
    spawn(){
        //下面是一些计算出的数字，实际使用可以自己改
        //cha 350 - 450 上下柱子的差值
        //topY =  botton - cha  上边柱子的y轴值为下面柱子的y轴值减去差值 //y轴顶为0
        //bottomY 300-600 底部柱子的y轴值
        //x:2040    柱子生成的x轴固定值，在右边屏幕外面

        //通过对象池标示符选择创建方法，返回生成的柱子
        var bottomzhu = Laya.Pool.getItemByCreateFun("zhu",this.createzhu,this);
        //底部柱子的旋转设成0；
        bottomzhu.rotation = 0;
        //获取新生成的底部柱子的加分脚本，打开加分开关
        bottomzhu.getComponent(AddScore).isAddScore = true;
        //用随机方法生成底部柱子的y轴值
        var bottomY = this.getRandom(300,600); 
        //在zhuManage容器中添加底部柱子为子节点
        this.zhuManage.addChild(bottomzhu);
        //设置底部柱子生成的位置
        bottomzhu.pos(2040,bottomY);
        //向zhuArr柱子集合中加入新生成的底部柱子
        zhuArr.push(bottomzhu);

        //生成随机差值
        var cha = this.getRandom(350,450);

        //通过对象池标示符选择创建方法，返回生成的柱子
        var topzhu = Laya.Pool.getItemByCreateFun("zhu",this.createzhu,this);
        //顶部柱子的旋转设成180；
        topzhu.rotation = 180;
        //获取新生成的顶部柱子的加分脚本，关闭加分开关
        topzhu.getComponent(AddScore).isAddScore = false;
        //差值运算生成顶部柱子的y轴值
        var topY = bottomY - cha;
        //在zhuManage容器中添加顶部柱子为子节点
        this.zhuManage.addChild(topzhu);
        //设置顶部柱子生成的位置
        topzhu.pos(2040,topY);
        //向zhuArr柱子集合中加入新生成的顶部柱子
        zhuArr.push(topzhu);
    }
    //生成柱子的方法
    createzhu(){
        //用dreate（），通过预制创建实例，生成柱子实例
        var temp = this.zhu.create() as Laya.Sprite;
        //返回生成的柱子实例
        return temp;
    }
    //游戏结束的方法
    Over(){
        //设置游戏结束开关为开
        this.isOver = true;
    }
    //游戏开始的方法
    GameStart(){
        //设置游戏结束开关为关
        this.isOver = false;
    }
    //再来一次的方法
    Again(){
        //设置游戏结束开关为关
        this.isOver = false;
        //通过zhuArr遍历柱子从父容器中删除自身
        zhuArr.forEach(element => {
            element.removeSelf();
        });
        //设置柱子数组zhuArr为空
        zhuArr = [];
    }



    //封装的随机输出方法，输入最小值和最大值，返回区间
    getRandom(min,max){
        //重置时间间隔
        var ranTime = 0;
        //这段有点多余，但我还是要解释一下
        //当最小值大于等于最大值，调用当前方法
        if(min >= max){
            //时间间隔为最小值（两值对比）加上Math.random()随机产生0-1和两值的差
            ranTime = max + Math.random() * (min - max);
        }
        //当最大值大于等于最小值，调用当前方法
        else if(max >= min){
            //时间间隔为最小值（两值对比）加上Math.random()随机产生0-1和两值的差
            ranTime = min + Math.random() * (max - min);
        }
        //返回时间间隔
        return ranTime;
    }
    }